// internal/api/user_controller.go
package api

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"

	"github.com/jfastfiler/internal/service"
)

type UserController struct {
	userService *service.UserService
}

func NewUserController(userService *service.UserService) *UserController {
	return &UserController{userService: userService}
}

// CreateUser 创建用户
// @Summary 创建用户（管理员）
// @Description 创建新用户，仅管理员可用
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param user body service.CreateUserRequest true "用户信息"
// @Success 200 {object} gin.H
// @Router /api/v1/users [post]
func (c *UserController) CreateUser(ctx *gin.Context) {
	var req service.CreateUserRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	createdBy := ctx.GetInt("user_id")
	err := c.userService.CreateUser(&req, createdBy)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"message": "用户创建成功"})
}

// UpdateUser 更新用户
// @Summary 更新用户信息
// @Description 更新用户信息，管理员可更新任何用户，普通用户只能更新自己的信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Param user body service.UpdateUserRequest true "用户信息"
// @Success 200 {object} gin.H
// @Router /api/v1/users/{id} [put]
func (c *UserController) UpdateUser(ctx *gin.Context) {
	userID, err := strconv.Atoi(ctx.Param("id"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
		return
	}

	var req service.UpdateUserRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 检查权限：普通用户只能更新自己的信息，管理员可以更新任何用户
	currentUserID := ctx.GetInt("user_id")
	currentUserRole := ctx.GetString("role")

	if currentUserRole != "admin" && currentUserID != userID {
		ctx.JSON(http.StatusForbidden, gin.H{"error": "没有权限更新该用户信息"})
		return
	}

	updatedBy := currentUserID
	err = c.userService.UpdateUser(userID, &req, updatedBy)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"message": "用户信息更新成功"})
}

// DeleteUser 删除用户
// @Summary 删除用户（管理员）
// @Description 删除用户，仅管理员可用
// @Tags 用户管理
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Success 200 {object} gin.H
// @Router /api/v1/users/{id} [delete]
func (c *UserController) DeleteUser(ctx *gin.Context) {
	userID, err := strconv.Atoi(ctx.Param("id"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
		return
	}

	deletedBy := ctx.GetInt("user_id")
	err = c.userService.DeleteUser(userID, deletedBy)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"message": "用户删除成功"})
}

// ListUsers 获取用户列表
// @Summary 获取用户列表（管理员）
// @Description 获取用户列表，仅管理员可用
// @Tags 用户管理
// @Produce json
// @Security Bearer
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(20)
// @Param username query string false "用户名过滤"
// @Param email query string false "邮箱过滤"
// @Param role query string false "角色过滤"
// @Param status query int false "状态过滤" Enums(0,1,2)
// @Success 200 {object} service.UserListResponse
// @Router /api/v1/users [get]
func (c *UserController) ListUsers(ctx *gin.Context) {
	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("page_size", "20"))
	username := ctx.Query("username")
	email := ctx.Query("email")
	role := ctx.Query("role")
	status, _ := strconv.Atoi(ctx.Query("status"))

	params := &service.UserQueryParams{
		Page:     page,
		PageSize: pageSize,
		Username: username,
		Email:    email,
		Role:     role,
		Status:   status,
	}

	users, total, err := c.userService.ListUsers(params)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"users": users,
		"total": total,
		"page":  page,
		"size":  pageSize,
	})
}

// GetUserProfile 获取用户资料
// @Summary 获取用户资料
// @Description 获取用户资料，普通用户只能获取自己的资料，管理员可以获取任何用户的资料
// @Tags 用户管理
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Success 200 {object} service.UserProfile
// @Router /api/v1/users/{id}/profile [get]
func (c *UserController) GetUserProfile(ctx *gin.Context) {
	userID, err := strconv.Atoi(ctx.Param("id"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
		return
	}

	// 检查权限：普通用户只能获取自己的资料，管理员可以获取任何用户的资料
	currentUserID := ctx.GetInt("user_id")
	currentUserRole := ctx.GetString("role")

	if currentUserRole != "admin" && currentUserID != userID {
		ctx.JSON(http.StatusForbidden, gin.H{"error": "没有权限查看该用户资料"})
		return
	}

	profile, err := c.userService.GetUserProfile(userID)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, profile)
}

// UpdateUserProfile 更新用户资料
// @Summary 更新用户资料
// @Description 更新用户资料，普通用户只能更新自己的资料
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Param profile body service.UpdateProfileRequest true "用户资料"
// @Success 200 {object} gin.H
// @Router /api/v1/users/{id}/profile [put]
func (c *UserController) UpdateUserProfile(ctx *gin.Context) {
	userID, err := strconv.Atoi(ctx.Param("id"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
		return
	}

	// 检查权限：普通用户只能更新自己的资料
	currentUserID := ctx.GetInt("user_id")
	currentUserRole := ctx.GetString("role")

	if currentUserRole != "admin" && currentUserID != userID {
		ctx.JSON(http.StatusForbidden, gin.H{"error": "没有权限更新该用户资料"})
		return
	}

	var updates map[string]interface{}
	if err := ctx.ShouldBindJSON(&updates); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	err = c.userService.UpdateUserProfile(userID, updates)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"message": "用户资料更新成功"})
}

// ResetPassword 重置密码（管理员）
// @Summary 重置用户密码（管理员）
// @Description 重置用户密码，仅管理员可用
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Param data body service.ResetPasswordRequest true "密码信息"
// @Success 200 {object} gin.H
// @Router /api/v1/users/{id}/reset-password [post]
func (c *UserController) ResetPassword(ctx *gin.Context) {
	userID, err := strconv.Atoi(ctx.Param("id"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": "无效的用户ID"})
		return
	}

	var req service.ResetPasswordRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	resetBy := ctx.GetInt("user_id")
	err = c.userService.ResetPassword(userID, req.NewPassword, resetBy)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"message": "密码重置成功"})
}